| The Application Kit Table of Contents | The Application Kit Index |
Derived from: none
Declared in: be/app/Clipboard.h
Library: libbe.so
Allocation: Constructor, on the stack, or use the
A BClipboard object is an interface to a clipboard, a resource that provides system-wide, temporary data storage. Clipboards are identified by name; if two apps want to refer to the same clipboard, they simply create respective BClipboard objects with the same name:
/* App A: This creates a clipboard named "MyClipboard". */
BClipboard *appAclipboard = new BClipboard("MyClipboard");
/* App B: This object refers to the clipboard already created by App A. */
BClipboard *appBclipboard = new BClipboard("MyClipboard");
In practice, you rarely need to construct your own BClipboard object; instead, you use the BClipboard that's created for you by your BApplication object. This object, which you refer to through the global be_clipboard variable, accesses the default system clipboard. Data that you write to your be_clipboard object can be read from any other app's be_clipboard. For example, the cut/copy/paste operations defined by BTextView transfer data through the system clipboard.
|
To access a clipboard's data, you call functions on a BMessage that the BClipboard object hands you (through its Data() function). The BMessage follows these conventions:
The following annotated example shows how to write to the clipboard.
BMessage *clip = (BMessage *)NULL;
if (be_clipboard->Lock()1) {
be_clipboard->Clear()2;
if ((clip = be_clipboard->Data()3) {
clip->AddData("text/MyFormat", B_MIME_TYPE, myText, myLength)4;
clip->AddData("text/plain", B_MIME_TYPE, asciiText, asciiLength)4;
be_clipboard->Commit()5;
}
be_clipboard->Unlock()6;
}
1 Lock() your BClipboard object. This uploads data from the clipboard into your BClipboard's local BMessage object, and prevents other threads in your application from accessing the BClipboard's data. Note that locking does not lock the underlying clipboard data—other applications can change the clipboard while you have your object locked.
2 Prepare the BClipboard for writing by calling Clear(). This erases the data that was uploaded from the clipboard.
3 Call Data() to get a pointer to the BClipboard's BMessage object.
4 Write the data by invoking AddData() directly on the BMessage. In the example, we write the data in two different formats.
5 Call Commit() to copy your BMessage back to the clipboard. As soon as you call Commit(), the data that you added is visible to other clipboard clients.
6 Unlock() balances the Lock(). The BClipboard object can now be accessed by other threads in your application.
If you decide that you don't want to commit your changes, you should call Revert() before you unlock.
Here we show how to read a simple string from the clipboard.
const char *text;
int32 textLen;
BMessage *clip = (BMessage *)NULL;
if (be_clipboard->Lock()1) {
if ((clip = be_clipboard->Data();
clip->FindData("text/plain", B_MIME_TYPE,
(const void **)&text, &textlen)2;
be_clipboard->Unlock()3;
}
1 As in writing, we bracket the operation with Lock() and Unlock(). Keep in mind that Lock() uploads data from the clipboard into our object. Any changes that are made to the clipboard (by some other application) after Lock() is called won't be seen here.
2 In this example, we only look for one hard-coded format. In a real application, you may have a list of formats that you can look for.
3 It isn't necessary to examine the clipboard data before you unlock it. The FindData() call could just as well have been performed after the Unlock() call.
Inter-boot persistence: Clipboard data does not persist between boots—the constructor provides a persistence flag, but it's currently unused.
Intra-boot persistence: Once you've created a clipboard, that clipboard will exist until you reboot your computer. For example, let's say you design an app that creates a clipboard called "MyClip": You launch the app, write something to "MyClip", and then quit the app. The clipboard—and the data that you wrote to it—will still exist: If you relaunch your app (or any app that knows about "MyClip"), you can pick up the data by reading from the "MyClip" clipboard.
|
Creates a new BClipboard object that refers to the name clipboard. The clipboard itself is created if a clipboard of that name doesn't already exist.
The discard flag is currently unused.
|
Destroys the BClipboard object. The clipboard itself and the data it contains are not affected by the object's destruction.
|
These functions are used when you're writing data to the clipboard. Clear() prepares your BClipboard for writing. You call Clear() just before you add new data to your clipboard message. Commit() copies your BClipboard data back to the clipboard. See "Writing to the Clipboard" for an example of these functions.
Revert() refreshes the BClipboard's data message by uploading it from the clipboard. The function is provided for the (rare) case where you alter your BClipboard's data message, and then decide to back out of the change. In this case, you should call Revert() (rather than Commit()). If you don't revert, your BClipboard's message will still contain your unwanted change, even if you unlock and then re-lock the object.
All three functions returns B_ERROR if the BClipboard isn't locked, and B_OK otherwise.
|
Returns the BMessage object that holds the BClipboard's data, or NULL if the BClipboard isn't locked. You're expected to read and write the BMessage directly; however, you may not free it or dispatch it like a normal BMessage. If you change the BMessage and want to write it back to the clipboard, you have to call Commit() after you make the change.
See "The Clipboard Message" for more information.
|
Returns a BMessenger that targets the BApplication object of the application that last committed data to the clipboard. The BClipboard needn't be locked.
|
These functions return the clipboard count. LocalCount() uses a cached count, while SystemCount() asks the Application Server for the more accurate system counter.
|
Lock() uploads data from the clipboard into your BClipboard object, and locks the object so no other thread in your application can use it. You must call Lock() before reading or writing the BClipboard. Lock() blocks if the object is already locked. It returns true if the lock was acquired, and false if the BClipboard object was deleted while Lock() was blocked.
|
Unlock() unlocks the object so other threads in your application can use it.
IsLocked() hardly needs to be documented.
|
Returns the name of the clipboard. The object needn't be locked.
|
If you want to be alerted when the clipboard changes, call StartWatching(), passing a BMessenger to be the target for the notification. When the clipboard changes, a B_CLIPBOARD_CHANGED message will be sent to the target.
StopWatching() stops monitoring the clipboard for changes.
RETURN CODES
B_OK. No error.
| The Application Kit Table of Contents | The Application Kit Index |
Copyright © 2000 Be, Inc. All rights reserved..
